/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow1Stride1Grad =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Backpropagate>;
TYPED_TEST_SUITE(AvgWindow1Stride1Grad, GTestTypePairs);
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11.,
      12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
      23., 24., 25., 26., 27., 28., 29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME1x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13.,
      14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.,
      27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
      40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52.,
      53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID1x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13.,
      14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.,
      27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
      40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52.,
      53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13., 14., 15., 16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25., 26., 27., 28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37., 38., 39., 40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49., 50., 51., 52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61., 62., 63., 64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73., 74., 75., 76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85., 86., 87., 88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97., 98., 99., 100., 101., 102., 103., 104., 105., 106., 107., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13., 14., 15., 16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25., 26., 27., 28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37., 38., 39., 40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49., 50., 51., 52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61., 62., 63., 64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73., 74., 75., 76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85., 86., 87., 88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97., 98., 99., 100., 101., 102., 103., 104., 105., 106., 107., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x3x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x3x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14., 15.,
      16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28., 29., 30.,
      31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45.,
      46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x3x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27., 28.,
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, SAME3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow1Stride1Grad, VALID3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,   10.,  11.,  12.,
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<1, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
